package grupobbva.pe.operhc.dao;

import java.math.BigDecimal;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.StringTokenizer;

import org.apache.commons.lang.StringUtils;
import org.apache.log4j.Logger;

import com.ibatis.dao.client.DaoManager;

import grupobbva.pe.operhc.domain.Canal;
import grupobbva.pe.operhc.domain.Cliente;
import grupobbva.pe.operhc.domain.ConfigProducto;
import grupobbva.pe.operhc.domain.Contrato;
import grupobbva.pe.operhc.domain.EmisoraConfigProd;
import grupobbva.pe.operhc.domain.Ingreso;
import grupobbva.pe.operhc.domain.LogDataLoad;
import grupobbva.pe.operhc.domain.Mensaje;
import grupobbva.pe.operhc.domain.Parametro;
import grupobbva.pe.operhc.domain.PerfilRol;
import grupobbva.pe.operhc.domain.Plazo;
import grupobbva.pe.operhc.domain.Producto;
import grupobbva.pe.operhc.domain.ProductoPlazo;
import grupobbva.pe.operhc.domain.SegParametros;
import grupobbva.pe.operhc.domain.SegUsuario;
import grupobbva.pe.operhc.domain.Segmento;
import grupobbva.pe.operhc.domain.SegmentoConfigProd;
import grupobbva.pe.operhc.domain.SubCanal;
import grupobbva.pe.operhc.domain.SubProducto;
import grupobbva.pe.operhc.domain.Tabla;
import grupobbva.pe.operhc.domain.TipoParametro;
import grupobbva.pe.operhc.service.BaseSqlMapDao;
import static grupobbva.pe.operhc.util.Constant.*;

public class ParametroDAOImpl extends BaseSqlMapDao implements ParametroDAO{
	
	private static Logger logger = Logger.getLogger(ParametroDAOImpl.class);
	
	public ParametroDAOImpl(DaoManager daoManager){
		super(daoManager);
	}

	/**********************************************
	 * @author frank.ayala
	 * INI MANTENIMIENTOS
	 **********************************************/
	
	public List<SegUsuario> getAllUsers() {
		return queryForList("SegUsuario.getAllUsers");
	}

	public List<SegParametros> getListOptions() {
		return queryForList("SegUsuario.getListOptions");
	}
	
	public SegUsuario getUserByCode(String id, String nivel) {
		
		Map<String, String> map = new HashMap<String, String>();
		map.put("codUsuario", id);
		
		List<SegUsuario> list = queryForList("SegUsuario.getIfUserExistsInAppByUsu", map);
		if(list != null && !list.isEmpty()){
			SegUsuario usuario = list.get(0);
			if("1".equals(usuario.getAdmin())){
				usuario.setStAdmin("true");
			}else{
				usuario.setStAdmin("false");
			}
			return usuario;
		}
		
		return new SegUsuario();
	}
	
	public Producto getProductByCode(String codProducto, String nivel) {
		
		List<Producto> listProduct = queryForList("Operativizacion.getProductByCode", codProducto);
		if(listProduct != null && !listProduct.isEmpty()){
			return listProduct.get(0);
		}
		
		return new Producto();
	}
	
	public List<SegParametros> getListUserOptions(String id) {
		
		Map<String, String> map = new HashMap<String, String>();
		map.put("codUsuario", id);
		return queryForList("SegUsuario.getListUserOptions", map);
	}
	
	public void deleteUsersByCode(String concatIds) throws Exception {
		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", concatIds);
		delete("SegUsuario.deleteOptionsUserByCode", map);
		delete("SegUsuario.deleteUsersByCode", map);
	}
	
	public boolean verifyUserUniquePK(String codigo) {

		Map<String, String> map = new HashMap<String, String>();
		map.put("codUsuario", codigo.trim());
		
		List<SegUsuario> list = queryForList("SegUsuario.getIfUserExistsInAppByUsu", map);
		if(list != null && !list.isEmpty()){
			return true;
		}
		
		return false;
	}

	public void saveUser(SegUsuario bean, boolean isNew) throws Exception {
		
		String codigo = bean.getCodigo();
		String tipoUsu = bean.getTipoUsu();
		String isAdmin = bean.getStAdmin();
		
		if("S".equalsIgnoreCase(isAdmin)){
			bean.setAdmin("1");
		}else{
			bean.setAdmin("0");
		}
		
		if(StringUtils.isNotBlank(codigo)){
			codigo = codigo.trim();
		}
		
		if(StringUtils.isNotBlank(tipoUsu)){
			tipoUsu = tipoUsu.trim();
		}
		
		bean.setCodigo(codigo);
		bean.setTipoUsu(tipoUsu);
		
		SegParametros param = new SegParametros();
		String[] arrayOpc = bean.getCmbReasonDestination();
		
		if(isNew){
			
			insert("SegUsuario.insertUser", bean);			
			for (int i = 0; i < arrayOpc.length; i++) {
				
				param.setCodigoOpcion(arrayOpc[i]);
				param.setCodigoUsuario(bean.getCodigo());
				insert("SegUsuario.insertOptionsUser", param);
			}			
			
		}else{
			
			Map<String, String> map = new HashMap<String, String>();
			map.put("codes", "'"+bean.getCodigo()+"'");
			delete("SegUsuario.deleteOptionsUserByCode", map);
			update("SegUsuario.updateUser", bean);
			
			for (int i = 0; i < arrayOpc.length; i++) {
				
				param.setCodigoOpcion(arrayOpc[i]);
				param.setCodigoUsuario(bean.getCodigo());
				insert("SegUsuario.insertOptionsUser", param);
			}
		}
	}

	public List<Parametro> getAllParameters() {
		return queryForList("Operativizacion.getAllParameters");
	}

	public List<Ingreso> getAllIncome() {
		
		List<Ingreso> list = queryForList("Operativizacion.getAllIncome");
		BigDecimal numCuotaFinal = BigDecimal.ZERO;
		BigDecimal numMinFinal = BigDecimal.ZERO;
		BigDecimal numMaxFinal = BigDecimal.ZERO;
		int indexDelete = 0;
		
		if(list != null){
			if(list.size() > 1){
		
				for (int i = 0; i < list.size(); i++) {
					
					Ingreso bean = list.get(i);
					numMaxFinal = bean.getNumMax();
					
					if(numMaxFinal == null){
						numCuotaFinal = bean.getNumCuota();
						numMinFinal = bean.getNumMin();				
						indexDelete = i;
						break;
					}
				}
				
				list.remove(indexDelete);
				Ingreso bean = list.get(0);
				bean.setNumMinFinal(numMinFinal);
				bean.setNumCuotaFinal(numCuotaFinal);
				list.set(0, bean);				
				
			}else if(list.size() == 1){
				
				Ingreso bean = list.get(0);
				bean.setNumMinFinal(bean.getNumMin());
				bean.setNumCuotaFinal(bean.getNumCuota());
				bean.setNumCuota(null);
				bean.setNumMax(null);
				bean.setNumMin(null);				
				list.set(0, bean);
			}
		}
		
		return list;		
	}

	public List<SubProducto> getAllSubproductos(String codConfigProducto, String codProductoPadre) {
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codConfigProducto", codConfigProducto);
		mapParam.put("codProductoPadre", codProductoPadre);
		return queryForList("Operativizacion.getAllSubproductos", mapParam);
	}

	public void deleteSubProductsByCode(String codes, String codProductoPadre, String codConfigProducto) throws Exception {
		
		Map<String, String> map = new HashMap<String, String>();
		map.put("codConfigProducto", codConfigProducto);
		map.put("codProductoPadre", codProductoPadre);		
		map.put("codes", codes);
		
		delete("Operativizacion.deleteSubProductsByCode", map);
	}

	public List<Producto> getAllProducts() {
		return queryForList("Operativizacion.getAllProducts");
	}

	public boolean saveAdminParameters(String strBuro, String strClasifbbva,
		String strValse, String strClasifsf, String strValrp, String allSegmentos) {

		Map<String, String> mapParam = new HashMap<String, String>();
		
		try{
		
			if("".equals(strBuro)){
				mapParam = new HashMap<String, String>();
				mapParam.put("columna", VALBURO);
				update("Operativizacion.updateAllInactiveParameter", mapParam);
			}else{
				mapParam = new HashMap<String, String>();
				mapParam.put("valor", strBuro);
				mapParam.put("columna", VALBURO);		
				update("Operativizacion.updateActiveParameter", mapParam);
				update("Operativizacion.updateInactiveParameter", mapParam);
			}			
			
			if("".equals(strClasifbbva)){
				mapParam = new HashMap<String, String>();
				mapParam.put("columna", CLASIFBBVA);
				update("Operativizacion.updateAllInactiveParameter", mapParam);
			}else{
				mapParam = new HashMap<String, String>();
				mapParam.put("valor", strClasifbbva);
				mapParam.put("columna", CLASIFBBVA);
				update("Operativizacion.updateActiveParameter", mapParam);
				update("Operativizacion.updateInactiveParameter", mapParam);
			}
			
			if("".equals(strClasifsf)){
				mapParam = new HashMap<String, String>();
				mapParam.put("columna", CLASIFSF);
				update("Operativizacion.updateAllInactiveParameter", mapParam);
			}else{
				mapParam = new HashMap<String, String>();
				mapParam.put("valor", strClasifsf);
				mapParam.put("columna", CLASIFSF);
				update("Operativizacion.updateActiveParameter", mapParam);
				update("Operativizacion.updateInactiveParameter", mapParam);
			}
			
			if("".equals(strValrp)){
				mapParam = new HashMap<String, String>();
				mapParam.put("columna", VALRP);
				update("Operativizacion.updateAllInactiveParameter", mapParam);
			}else{
				mapParam = new HashMap<String, String>();
				mapParam.put("valor", strValrp);
				mapParam.put("columna", VALRP);
				update("Operativizacion.updateActiveParameter", mapParam);
				update("Operativizacion.updateInactiveParameter", mapParam);
			}
			
			mapParam = new HashMap<String, String>();
			mapParam.put("valor", strValse);
			mapParam.put("columna", VALSE);
			update("Operativizacion.updateValParametro", mapParam);
			
			mapParam = new HashMap<String, String>();
			mapParam.put("valor", allSegmentos);
			mapParam.put("codParametro", ALL_SEGMENTO);
			mapParam.put("codTipoParametro", SIN_TIPO);
			update("Operativizacion.updateValParametroByCodes", mapParam);
			
			return true;
		
		}catch(Exception e){
			e.printStackTrace();
			return false;	
		}		
	}

	public Map<String, String> saveAdminIncomes(List<Ingreso> listIngreso) {

		Map<String, String> mapResult = new HashMap<String, String>();
		if(listIngreso.size() > 0){
			
			try{

				delete("Operativizacion.cleanIncomes");
				
				boolean isUniqueRegister = false;
				for (int i = 0; i < listIngreso.size(); i++) {
					
					Ingreso ingreso = listIngreso.get(i);
					if(ingreso != null){
						
						if(listIngreso.size() == 1){
							
							try {
								
								Double.parseDouble(ingreso.getValMin());
								Double.parseDouble(ingreso.getValMax());
								
								insert("Operativizacion.insertIncome", ingreso);
								insert("Operativizacion.insertIncomeFinal", ingreso);
								
							} catch (Exception e) {
								// frk: si entra aca es por que no necesariamente 
								// vienen los valores valMin y valMax
								insert("Operativizacion.insertIncomeFinal", ingreso);							
							}
							
							isUniqueRegister = true;
							
						}else{							
							if(!"".equals(ingreso.getValMin()) || !"".equals(ingreso.getValMax()) || !"".equals(ingreso.getValCuota())){
								insert("Operativizacion.insertIncome", ingreso);
							}
						}					
					}
					
					if(!isUniqueRegister && listIngreso.size() - 1 == i){
						insert("Operativizacion.insertIncomeFinal", listIngreso.get(0));					
					}
				}
			
			}catch(Exception e){
				e.printStackTrace();
				mapResult.put("msgError", "etiqueta.error.save");
				return mapResult;
			}
		}
		
		return mapResult;
	}

	public void deleteProductsByCode(String codes) throws Exception{

		String concatConfigProd = "";
		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", codes);
		
		List<ConfigProducto> listConfigProducto = queryForList("Operativizacion.getConfigProductsByCodesProduct", map);
		if(listConfigProducto != null){
			for (int i = 0; i < listConfigProducto.size(); i++) {
				
				concatConfigProd += "'"+listConfigProducto.get(i).getCodConfigProducto()+"',";
			}			
		}
		
		if(!"".equals(concatConfigProd)){
			concatConfigProd = concatConfigProd.substring(0, concatConfigProd.length()-1);
			delete("Operativizacion.deleteSubProductConfigProdByCode", concatConfigProd);
			delete("Operativizacion.deleteSegmentoConfigProdByCode", concatConfigProd);
			delete("Operativizacion.deleteEmisoraConfigProdByCode", concatConfigProd);
		}

		delete("Operativizacion.deleteProdPlazosByCode", map);
		delete("Operativizacion.deleteConfigProductByProduct", map);
		delete("Operativizacion.deleteProductsByCode", map);
	}

	public Map<String, String> saveProduct(String codProductoHdn, String codProducto,
		String desProducto, String stMultCont, String stNivela, String familia, 
		String stContrata, String stSimula) {
		
		Map<String, String> mapResult = new HashMap<String, String>();
		Producto bean = new Producto();
		
		try {
			
			if("yes".equalsIgnoreCase(stNivela) || 
			   "on".equalsIgnoreCase(stNivela) || 
			   "1".equalsIgnoreCase(stNivela)){
				stNivela = "1";
			}else{
				stNivela = "0";
			}
			
			if("yes".equalsIgnoreCase(stContrata) || 
			   "on".equalsIgnoreCase(stContrata) || 
			   "1".equalsIgnoreCase(stContrata)){
				stContrata = "1";
			}else{
				stContrata = "0";
			}
			
			if("yes".equalsIgnoreCase(stSimula) || 
			   "on".equalsIgnoreCase(stSimula) || 
			   "1".equalsIgnoreCase(stSimula)){
				stSimula = "1";
			}else{
				stSimula = "0";
			}
			
			if("yes".equalsIgnoreCase(stMultCont) || 
			   "on".equalsIgnoreCase(stMultCont) || 
			   "1".equalsIgnoreCase(stMultCont)){
				stMultCont = "1";
			}else{
				stMultCont = "0";
			}
			
			if(StringUtils.isBlank(codProductoHdn)){
				codProductoHdn = "";
			}
			
			if(StringUtils.isBlank(familia)){
				familia = "";
			}
			
			bean.setCodProductoHdn(codProductoHdn);
			bean.setCodProducto(codProducto.toUpperCase().trim());
			bean.setDesProducto(desProducto.trim());
			bean.setNivelaOferta(stNivela);
			bean.setContrata(stContrata);
			bean.setSimula(stSimula);
			bean.setMultCont(stMultCont);
			bean.setFamilia(familia);
			
			List<Producto> listProduct = queryForList("Operativizacion.getProductByCode", bean.getCodProductoHdn());
			if(!listProduct.isEmpty()){
				update("Operativizacion.updateProduct", bean);
				
				if(!bean.getCodProductoHdn().equals(bean.getCodProducto())){
					update("Operativizacion.updateCodProductoToConfigProducto", bean);
					update("Operativizacion.updateCodProductoToProductoPlazo", bean);
				}
				
			}else{
				insert("Operativizacion.insertProduct", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.products.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.products.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}		
		}
		
		return mapResult;
	}

	public List<ConfigProducto> getAllConfigProducts(String codProductoPadre) {
		return queryForList("Operativizacion.getAllConfigProducts", codProductoPadre);
	}
	
	public ConfigProducto getConfigProductByCode(String codConfigProducto, String codProductoPadre) {
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codConfigProducto", codConfigProducto);
		mapParam.put("codProducto", codProductoPadre);
		
		List<ConfigProducto> listConfigProduct = queryForList("Operativizacion.getConfigProductByCode", mapParam);
		if(listConfigProduct != null && !listConfigProduct.isEmpty()){
			return listConfigProduct.get(0);
		}
		
		return new ConfigProducto();
	}

	public Map<String, String> saveConfigProduct(String codConfigProductoHdn,
		String codConfigProducto, String desConfigProducto,
		String codProductoPadre, Long valPrioridad) {

		Map<String, String> mapParam = new HashMap<String, String>();
		Map<String, String> mapResult = new HashMap<String, String>();
		ConfigProducto bean = new ConfigProducto();
		
		try {
			
			if(StringUtils.isBlank(codConfigProductoHdn)){
				codConfigProductoHdn = "";
			}
			
			bean.setValPrioridad(valPrioridad);
			bean.setCodProductoPadre(codProductoPadre);
			bean.setCodConfigProductoHdn(codConfigProductoHdn);
			bean.setCodConfigProducto(codConfigProducto.toUpperCase().trim());
			bean.setDesConfigProducto(desConfigProducto.trim());
			
			mapParam.put("codConfigProducto", bean.getCodConfigProductoHdn());
			mapParam.put("desConfigProducto", desConfigProducto.trim());
			mapParam.put("codProducto", codProductoPadre);			
			
			List<ConfigProducto> listConfigProduct = queryForList("Operativizacion.getConfigProductByCode", mapParam);
			if(!listConfigProduct.isEmpty()){

				List<ConfigProducto> listRecords = queryForList("Operativizacion.getConfigProductByDescription", mapParam);
				if(!listRecords.isEmpty()){
					mapResult.put("msgError", "etiqueta.error.adminform.configproducts.description");
				}else{
					bean.setCodConfigProducto(codConfigProductoHdn);
					update("Operativizacion.updateConfigProduct", bean);
				}
									
			}else{

				mapParam.put("codConfigProducto", null);
				List<ConfigProducto> listRecords = queryForList("Operativizacion.getConfigProductByDescription", mapParam);
				if(!listRecords.isEmpty()){
					mapResult.put("msgError", "etiqueta.error.adminform.configproducts.description");
				}else{
				
					codConfigProducto = (String)queryForObject("Operativizacion.getSequencialConfigProducto");
					bean.setCodConfigProducto(codConfigProducto);
					
					insert("Operativizacion.insertConfigProduct", bean);
					mapResult.put("idGenerado", codConfigProducto);
				}
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.configproducts.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.configproducts.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteConfigProductsByCode(String codes, String codProductoPadre)
		throws Exception {

		Map<String, String> map = new HashMap<String, String>();
		map.put("codProductoPadre", codProductoPadre);
		map.put("codes", codes);		
		
		if(!"".equals(codes)){
			delete("Operativizacion.deleteSubProductConfigProdByCode", codes);
			delete("Operativizacion.deleteSegmentoConfigProdByCode", codes);
			delete("Operativizacion.deleteEmisoraConfigProdByCode", codes);
			delete("Operativizacion.deleteConfigProductByCode", map);
		}	
	}

	public List<EmisoraConfigProd> getAllEmisorasConfigProd(
		String codConfigProducto, String codProductoPadre) {
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codConfigProducto", codConfigProducto);
		mapParam.put("codProductoPadre", codProductoPadre);
		
		List<EmisoraConfigProd> listEmisoras = queryForList("Operativizacion.getAllEmisoras", mapParam);
		List<EmisoraConfigProd> listEmisorasCP = queryForList("Operativizacion.getAllEmisorasConfigProd", mapParam);
		
		for (int i = 0; i < listEmisoras.size(); i++) {
			EmisoraConfigProd bean = listEmisoras.get(i);
			String codEmisoraPadre = bean.getCodEmisora();
			for (int j = 0; j < listEmisorasCP.size(); j++) {
				String codEmisoraHijo = listEmisorasCP.get(j).getCodEmisora();
				if(codEmisoraPadre.equals(codEmisoraHijo)){
					bean.setSeleccionEmisora(listEmisorasCP.get(j).getSeleccionEmisora());
					listEmisoras.set(i, bean);
					break;
				}
			}			
		}
		
		return listEmisoras;
	}

	public List<SegmentoConfigProd> getAllSegmentosConfigProd(
		String codConfigProducto, String codProductoPadre) {
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codConfigProducto", codConfigProducto);
		mapParam.put("codProductoPadre", codProductoPadre);
		
		List<SegmentoConfigProd> listSegmentos = queryForList("Operativizacion.getAllSegmentos", mapParam);
		List<SegmentoConfigProd> listSegmentosCP = queryForList("Operativizacion.getAllSegmentosConfigProd", mapParam);
		
		for (int i = 0; i < listSegmentos.size(); i++) {
			SegmentoConfigProd bean = listSegmentos.get(i);
			String codSegmentoPadre = bean.getCodSegmento();
			for (int j = 0; j < listSegmentosCP.size(); j++) {
				String codSegmentoHijo = listSegmentosCP.get(j).getCodSegmento();
				if(codSegmentoPadre.equals(codSegmentoHijo)){
					bean.setSeleccionSegmento(listSegmentosCP.get(j).getSeleccionSegmento());
					listSegmentos.set(i, bean);
					break;
				}
			}			
		}
		
		return listSegmentos;
	}

	public Map<String, String> saveEmisora(String codConfigProductoHdn,
			String codEmisoraHdn, String codEmisora, String desEmisora, 
			String seleccionEmisora) {
		
		Map<String, String> mapParam = new HashMap<String, String>();
		Map<String, String> mapResult = new HashMap<String, String>();
		EmisoraConfigProd bean = new EmisoraConfigProd();
		
		try {
			
			if("yes".equalsIgnoreCase(seleccionEmisora) || 
			   "on".equalsIgnoreCase(seleccionEmisora) || 
			   "1".equalsIgnoreCase(seleccionEmisora)){
				seleccionEmisora = "1";
			}else{
				seleccionEmisora = "0";
			}
			
			if(StringUtils.isBlank(codConfigProductoHdn)){
				codConfigProductoHdn = "";
			}
			
			bean.setCodEmisoraHdn(codEmisoraHdn);
			bean.setSeleccionEmisora(seleccionEmisora);
			bean.setCodConfigProductoHdn(codConfigProductoHdn);
			bean.setCodEmisora(codEmisora.toUpperCase().trim());
			bean.setDesEmisora(desEmisora.trim());
			
			mapParam.put("codConfigProducto", bean.getCodConfigProductoHdn());
			mapParam.put("codEmisora", codEmisoraHdn);
			
			List<EmisoraConfigProd> listEmisora = queryForList("Operativizacion.getEmisoraByCode", mapParam);
			List<EmisoraConfigProd> listEmisoraCP = queryForList("Operativizacion.getEmisoraConfigProdByCode", mapParam);
			
			if(!listEmisora.isEmpty()){
				update("Operativizacion.updateEmisora", bean);					
			}else{
				insert("Operativizacion.insertEmisora", bean);
			}
			
			if(!listEmisoraCP.isEmpty()){
				update("Operativizacion.updateEmisoraConfigProd", bean);					
			}else{
				insert("Operativizacion.insertEmisoraConfigProd", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.emisora.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.emisora.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public Map<String, String> saveSegmento(String codConfigProductoHdn,
			String codSegmentoHdn, String codSegmento, String desSegmento, 
			String seleccionSegmento) {

		Map<String, String> mapParam = new HashMap<String, String>();
		Map<String, String> mapResult = new HashMap<String, String>();
		SegmentoConfigProd bean = new SegmentoConfigProd();
		
		try {
			
			if("yes".equalsIgnoreCase(seleccionSegmento) || 
			   "on".equalsIgnoreCase(seleccionSegmento) || 
			   "1".equalsIgnoreCase(seleccionSegmento)){
				seleccionSegmento = "1";
			}else{
				seleccionSegmento = "0";
			}
			
			if(StringUtils.isBlank(codConfigProductoHdn)){
				codConfigProductoHdn = "";
			}
			
			bean.setCodSegmentoHdn(codSegmentoHdn);
			bean.setSeleccionSegmento(seleccionSegmento);
			bean.setCodConfigProductoHdn(codConfigProductoHdn);
			bean.setCodSegmento(codSegmento.toUpperCase().trim());
			bean.setDesSegmento(desSegmento.trim());
			
			mapParam.put("codConfigProducto", bean.getCodConfigProductoHdn());
			mapParam.put("codSegmento", codSegmentoHdn);
			
			List<SegmentoConfigProd> listSegmento = queryForList("Operativizacion.getSegmentoByCode", mapParam);
			List<SegmentoConfigProd> listSegmentoCP = queryForList("Operativizacion.getSegmentoConfigProdByCode", mapParam);
			
			if(!listSegmento.isEmpty()){
				update("Operativizacion.updateSegmento", bean);					
			}else{
				insert("Operativizacion.insertSegmento", bean);
			}
			
			if(!listSegmentoCP.isEmpty()){
				update("Operativizacion.updateSegmentoConfigProd", bean);					
			}else{
				insert("Operativizacion.insertSegmentoConfigProd", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.segmento.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.segmento.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteEmisorasByCode(String codes, String codProductoPadre,
		String codConfigProducto) throws Exception {

		if(!"".equals(codes)){
			
			Map<String, String> map = new HashMap<String, String>();
			map.put("codConfigProducto", codConfigProducto);
			map.put("codProductoPadre", codProductoPadre);
			map.put("codes", codes);		
			
			boolean isDeletedDetail = true;
			EmisoraConfigProd bean;
			List<EmisoraConfigProd> listEmisorasCP = queryForList("Operativizacion.getEmisorasAllConfigProd", map);
			if(!listEmisorasCP.isEmpty()){
				for (int i = 0; i < listEmisorasCP.size(); i++) {
					
					bean = listEmisorasCP.get(i);
					if("1".equals(bean.getSeleccionEmisora())){
						isDeletedDetail = false;
						break;
					}				
				}
				
				if(isDeletedDetail){
					delete("Operativizacion.deleteEmisoraConfigProdByCodEmisora", map);
				}
			}
		
			//frk: si existen otras configuraciones relacionadas a 
			//las emisoras seleccionadas no se deben de eliminar
			
			if(isDeletedDetail){
				delete("Operativizacion.deleteEmisoraByCode", map);
			}else{
				throw new Exception("ORA-02292");
			}
		}
	}

	public void deleteSegmentosByCode(String codes, String codProductoPadre,
		String codConfigProducto) throws Exception {
		
		if(!"".equals(codes)){
			
			Map<String, String> map = new HashMap<String, String>();
			map.put("codConfigProducto", codConfigProducto);
			map.put("codProductoPadre", codProductoPadre);
			map.put("codes", codes);		
			
			boolean isDeletedDetail = true;
			SegmentoConfigProd bean;
			List<SegmentoConfigProd> listSegmentosCP = queryForList("Operativizacion.getSegmentosAllConfigProd", map);
			if(!listSegmentosCP.isEmpty()){
				for (int i = 0; i < listSegmentosCP.size(); i++) {
					
					bean = listSegmentosCP.get(i);
					if("1".equals(bean.getSeleccionSegmento())){
						isDeletedDetail = false;
						break;
					}				
				}
				
				if(isDeletedDetail){
					delete("Operativizacion.deleteSegmentoConfigProdByCodSegmento", map);
				}
			}
			
			//frk: si existen otras configuraciones relacionadas a 
			//los segmentos seleccionados no se deben de eliminar
			
			if(isDeletedDetail){
				delete("Operativizacion.deleteSegmentoByCode", map);
			}else{
				throw new Exception("ORA-02292");
			}
		}
	}

	public Map<String, String> saveSubProduct(String codConfigProductoHdn,
		String codSubProducto, String desSubProducto, String valTasa, String valTipo, 
		String valBin, BigDecimal rangoMin, BigDecimal rangoMax, Long idSubProducto, String divisa) {

		Map<String, String> mapResult = new HashMap<String, String>();
		SubProducto bean = new SubProducto();
		
		try {
			
			if(StringUtils.isBlank(codConfigProductoHdn)){
				codConfigProductoHdn = "";
			}
			
			if(StringUtils.isBlank(valTasa)){
				valTasa = "";
			}
			
			if(StringUtils.isBlank(valBin)){
				valBin = "";
			}
			
			if(rangoMax != null && rangoMin == null){
				rangoMin = BigDecimal.ZERO;
			}else if(rangoMax != null && rangoMin != null){
				if(rangoMax.compareTo(rangoMin) <= 0){
					rangoMax = null;
				}
			}
			
			bean.setCodConfigProductoHdn(codConfigProductoHdn);
			bean.setCodSubProducto(codSubProducto.toUpperCase().trim());
			bean.setDesSubProducto(desSubProducto.trim());
			bean.setIdSubProducto(idSubProducto);
			
			bean.setValTasa(new BigDecimal(valTasa));
			bean.setRangoMin(rangoMin);
			bean.setRangoMax(rangoMax);
			bean.setValTipo(valTipo);
			bean.setValBin(valBin);
			bean.setDivisa(divisa);
			
			if(idSubProducto.intValue() == -1){
				
				String idsub = (String)queryForObject("Operativizacion.getSequencialSubProducto");
				bean.setIdSubProducto(new Long(idsub));
				
				insert("Operativizacion.insertSubProducto", bean);
				mapResult.put("idGenerado", idsub);
			}else{
				update("Operativizacion.updateSubProducto", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.subproducto.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.subproducto.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void saveConfigProductDetail(String stRiesgo, String codConfigProducto, String allEmisoras, String allSegmentos) {

		ConfigProducto bean = new ConfigProducto();
		bean.setCodConfigProducto(codConfigProducto);
		bean.setAllSegmento(allSegmentos);
		bean.setAllEmisora(allEmisoras);		
		bean.setStRiesgo(stRiesgo);
		
		update("Operativizacion.updateConfigProductoDetalle", bean);
	}

	public List<SubProducto> getAllStructureSubProducts(String codProducto, Cliente clienteSession) {

		String emisora  = clienteSession.getEmisora();
		String segmento = clienteSession.getSegmentoComercial();
		
		if(StringUtils.isBlank(emisora)){
			emisora = null;
		}
		
		if(StringUtils.isBlank(segmento)){
			segmento = null;
		}
		
		if(logger.isDebugEnabled()){
			logger.debug("* La emisora del cliente es: "+emisora);
			logger.debug("* El segmento del cliente es: "+segmento);
		}
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codProducto", codProducto);
		mapParam.put("segmento", 	segmento);
		mapParam.put("emisora",  	emisora);		
		
		List<SubProducto> list = queryForList("Operativizacion.getAllStructureSubProducts", mapParam);
		
		if(list.isEmpty())
		if(logger.isDebugEnabled()){
			logger.debug("* El producto con codigo ("+codProducto+") no tiene subproductos relacionados.");
		}
		
		return list;
	}

	public List<Plazo> getAllPlazos() {
		return queryForList("Operativizacion.getAllPlazos");
	}

	public Map<String, String> savePlazo(String codPlazoHdn, String codPlazo,
			String desPlazo) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Plazo bean = new Plazo();
		
		try {
			
			if(StringUtils.isBlank(codPlazoHdn)){
				codPlazoHdn = "";
			}
			
			bean.setCodPlazoHdn(codPlazoHdn);
			bean.setCodPlazo(codPlazo.toUpperCase().trim());
			bean.setDesPlazo(desPlazo.trim());
			
			List<Plazo> listPlazo = queryForList("Operativizacion.getPlazoByCode", bean.getCodPlazoHdn());
			if(!listPlazo.isEmpty()){
				update("Operativizacion.updatePlazo", bean);				
				if(!bean.getCodPlazoHdn().equals(bean.getCodPlazo())){
					update("Operativizacion.updateCodPlazoToProductoPlazo", bean);
				}				
			}else{
				insert("Operativizacion.insertPlazo", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.plazo.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.plazo.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deletePlazosByCode(String codes) throws Exception{

		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", codes);
		
		boolean isDeletedPlazoDetail = true;
		ProductoPlazo bean;
		List<ProductoPlazo> listProdPlazo = queryForList("Operativizacion.getProductoPlazosByCodes", map);
		if(!listProdPlazo.isEmpty()){
			for (int i = 0; i < listProdPlazo.size(); i++) {
				
				bean = listProdPlazo.get(i);
				if("1".equals(bean.getEstSeleccion())){
					isDeletedPlazoDetail = false;
					break;
				}				
			}
			
			if(isDeletedPlazoDetail){
				delete("Operativizacion.deleteProductoPlazosByCodPlazo", map);				
			}			
		}
		
		//frk: si existen datos relacionados a 
		//los plazos seleccionados no se deben de eliminar
		
		if(isDeletedPlazoDetail){
			delete("Operativizacion.deletePlazosByCode", map);
		}else{
			throw new Exception("ORA-02292");
		}
	}

	public List<ProductoPlazo> getAllConfigProductPlazo(String codProductoPadre) {
		
		ProductoPlazo beanFinal = new ProductoPlazo();
		List<ProductoPlazo> listFinal = new ArrayList<ProductoPlazo>();
		List<Plazo> listPlazos = queryForList("Operativizacion.getAllPlazos");
		List<ProductoPlazo> listProdPlazo = queryForList("Operativizacion.getAllConfigProductPlazo", codProductoPadre);
		
		for (int i = 0; i < listPlazos.size(); i++) {
			
			beanFinal = new ProductoPlazo();
			String codPlazoPadre = listPlazos.get(i).getCodPlazo();
			String desPlazoPadre = listPlazos.get(i).getDesPlazo();
			beanFinal.setCodProducto(codProductoPadre);
			beanFinal.setCodPlazo(codPlazoPadre);
			beanFinal.setDesPlazo(desPlazoPadre);
			beanFinal.setEstSeleccion("0");
			
			for (int j = 0; j < listProdPlazo.size(); j++) {
				
				String codPlazoHijo = listProdPlazo.get(j).getCodPlazo();
				if(codPlazoPadre.equals(codPlazoHijo)){
					beanFinal.setEstSeleccion(listProdPlazo.get(j).getEstSeleccion());
					break;
				}
			}
			
			listFinal.add(beanFinal);
		}
		
		return listFinal;
	}

	public List<Producto> getAllStructureProducts(List<Producto> listProductosCliente, List<Contrato> listContrato, String familiaMostrar) {
		
		if(logger.isDebugEnabled()){
			logger.debug("* entrando al ParametroDAOImpl.getAllStructureProducts *");
		}
		
		List<Producto> listProdFinal = new ArrayList<Producto>();
		Map<String, Object> datosContrato = new HashMap<String, Object>();
		Map<String, Object> datosProducto = new HashMap<String, Object>();
		String codesProduct = "";
		
		if(listProductosCliente != null){
			for (int i = 0; i < listProductosCliente.size(); ++i) {
			    Producto prodJSON = listProductosCliente.get(i);
			    datosProducto.put(prodJSON.getCodProducto(), prodJSON);
			    codesProduct = codesProduct + "'"+prodJSON.getCodProducto()+"',";
			}
			
			if(!"".equals(codesProduct)){
				codesProduct = codesProduct.substring(0, codesProduct.length()-1);
			}
		}
		
		if(listContrato != null){
			for (int i = 0; i < listContrato.size(); i++) {
				Contrato contrato = listContrato.get(i);
				if(SCORING_PROACTIVO.equalsIgnoreCase(contrato.getTipoScoring())) {
					if (!contrato.estaRechazado()) {
						datosContrato.put(contrato.getTipoProducto(), contrato);
					}
				}
			}
		}
		
		if(logger.isDebugEnabled()){
			logger.debug("* Lista de contratos PROACTIVOS del cliente: "+datosContrato);
		}
		
		boolean isUsedMultCont = false;
		Map<String, Object> mapParam = new HashMap<String, Object>();
		List<ProductoPlazo> listProdPlazo;
		Producto bean;
		
		if(codesProduct != ""){
		
			mapParam.put("codesProduct", codesProduct);
			mapParam.put("familiaMostrar", familiaMostrar);
			List<Producto> listProd = queryForList("Operativizacion.getAllStructureProducts", mapParam);
			if(!listProd.isEmpty()){
				
				if(logger.isDebugEnabled()){
					logger.debug("* Lista de productos encontrados en el sistema: \n"+listProd);
				}
				
				for (int i = 0; i < listProd.size(); i++) {
					
					isUsedMultCont = false;
					bean = listProd.get(i);
					
					//frk: si este producto no es multiple contrato y si existen contratos 
					//proactivos para este producto entonces el producto ya no es considerado
					if("0".equals(bean.getMultCont()) && datosContrato.get(bean.getCodProducto()) != null){
						isUsedMultCont = true;
						
						if(logger.isDebugEnabled()){
							logger.debug("* Este producto ("+bean.getDesProducto()+") no es multiple contrato y existen " +
							"contratos proactivos para este, entonces el producto ya no es considerado.");
						}
					}
					
					if(!isUsedMultCont){
						Producto objProducto = (Producto)datosProducto.
						get(bean.getCodProducto());
						
						mapParam = new HashMap<String, Object>();
						mapParam.put("codProductoPadre", bean.getCodProducto());
						
						if(objProducto != null){
							mapParam.put("plazo", objProducto.getPlazo());				
							bean.setPlazo(objProducto.getPlazo());
							bean.setCuota(objProducto.getCuota());
						}else{
							bean.setCuota(BigDecimal.ZERO);
						}
						
						listProdPlazo = queryForList("Operativizacion.getAllConfigProductPlazoActivo", mapParam);
						
						if(listProdPlazo.isEmpty()){
							if(logger.isDebugEnabled()){
								logger.debug("* Este producto ("+bean.getDesProducto()+") no tiene plazos relacionados " +
								"por lo que no sera considerado");
							}
						}
						
						if(bean.getCuota().compareTo(DIEZ) < 0){
							if(logger.isDebugEnabled()){
								logger.debug("* Este producto ("+bean.getDesProducto()+") tiene la cuota ("+bean.getCuota()+") " +
								"la cual es menor a DIEZ, por lo cual ya no sera considerado.");
							}
						}
						
						if(!listProdPlazo.isEmpty() && bean.getCuota().compareTo(DIEZ) >= 0){
							bean.setListProdPlazo(listProdPlazo);
							listProdFinal.add(bean);
						}
					}
				}
			}
		}else{
			if(logger.isDebugEnabled()){
				logger.debug("* No se retornan productos debido a que el cliente no cuenta con productos relacionados *");
			}
		}
		
		if(logger.isDebugEnabled()){
			logger.debug("* saliendo del ParametroDAOImpl.getAllStructureProducts *");
		}
		
		return listProdFinal;
	}

	public String getValParameterByCode(String codParametro, String codTipoParametro) {
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codParametro", codParametro);
		mapParam.put("codTipoParametro", codTipoParametro);
		
		return (String)queryForObject("Operativizacion.getValParameterByCode", mapParam);
	}

	public Map<String, String> saveCheckEmisoras(String selEmisoras,
			String codConfigProducto) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Map<String, String> mapParam = new HashMap<String, String>();
		EmisoraConfigProd bean = new EmisoraConfigProd();
		
		try{
		
			bean.setCodConfigProductoHdn(codConfigProducto);
			update("Operativizacion.updateInactiveAllCheckEmisora", bean);
			
			if(StringUtils.isNotBlank(selEmisoras)){

				StringTokenizer st = new StringTokenizer(selEmisoras, "$$");
				while (st.hasMoreTokens()) {
					
					String codEmisora = st.nextToken();				
					bean = new EmisoraConfigProd();
					
					bean.setCodEmisora(codEmisora);
					bean.setSeleccionEmisora("1");
					bean.setCodConfigProductoHdn(codConfigProducto);
					
					mapParam.put("codConfigProducto", codConfigProducto);
					mapParam.put("codEmisora", codEmisora);
					
					List<EmisoraConfigProd> listEmisoraCP = queryForList("Operativizacion.getEmisoraConfigProdByCode", mapParam);
					if(!listEmisoraCP.isEmpty()){
						update("Operativizacion.updateCheckEmisora", bean);
					}else{
						insert("Operativizacion.insertEmisoraConfigProd", bean);
					}
				}
			}
		
		} catch (Exception e) {
			e.printStackTrace();
			mapResult.put("msgError", "etiqueta.error.save");
		}
		
		return mapResult;
	}

	public Map<String, String> saveCheckSegmentos(String selSegmentos,
			String codConfigProducto) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Map<String, String> mapParam = new HashMap<String, String>();
		SegmentoConfigProd bean = new SegmentoConfigProd();
		
		try{
		
			bean.setCodConfigProductoHdn(codConfigProducto);
			update("Operativizacion.updateInactiveAllCheckSegmento", bean);
			
			if(StringUtils.isNotBlank(selSegmentos)){
				StringTokenizer st = new StringTokenizer(selSegmentos, "$$");
				while (st.hasMoreTokens()) {
					
					String codSegmento = st.nextToken();
					bean = new SegmentoConfigProd();
					bean.setSeleccionSegmento("1");
					bean.setCodSegmento(codSegmento);				
					bean.setCodConfigProductoHdn(codConfigProducto);
					
					mapParam.put("codConfigProducto", codConfigProducto);
					mapParam.put("codSegmento", codSegmento);
					
					List<SegmentoConfigProd> listSegmentoCP = queryForList("Operativizacion.getSegmentoConfigProdByCode", mapParam);
					if(!listSegmentoCP.isEmpty()){
						update("Operativizacion.updateCheckSegmento", bean);
					}else{
						insert("Operativizacion.insertSegmentoConfigProd", bean);
					}
				}
			}
		
		} catch (Exception e) {
			e.printStackTrace();
			mapResult.put("msgError", "etiqueta.error.save");
		}
		
		return mapResult;
	}

	public Map<String, String> saveCheckProducts(String selNivela,
		String selMultCont, String selContrata, String selSimula) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Producto bean = new Producto();
		
		try{
		
			update("Operativizacion.updateInactiveAllCheckProduct", bean);
			
			if(StringUtils.isNotBlank(selNivela)){
				StringTokenizer st = new StringTokenizer(selNivela, "$$");
				while (st.hasMoreTokens()) {
					
					String codProducto = st.nextToken();
					bean = new Producto();
					
					bean.setCodProducto(codProducto);
					bean.setNivelaOferta("1");
					
					update("Operativizacion.updateCheckNivelaProduct", bean);
				}
			}
			
			if(StringUtils.isNotBlank(selMultCont)){
				StringTokenizer st = new StringTokenizer(selMultCont, "$$");
				while (st.hasMoreTokens()) {
					
					String codProducto = st.nextToken();
					bean = new Producto();
					
					bean.setCodProducto(codProducto);
					bean.setMultCont("1");
					
					update("Operativizacion.updateCheckMultContProduct", bean);
				}
			}
			
			if(StringUtils.isNotBlank(selContrata)){
				StringTokenizer st = new StringTokenizer(selContrata, "$$");
				while (st.hasMoreTokens()) {
					
					String codProducto = st.nextToken();
					bean = new Producto();
					
					bean.setCodProducto(codProducto);
					bean.setContrata("1");
					
					update("Operativizacion.updateCheckContrataProduct", bean);
				}
			}
			
			if(StringUtils.isNotBlank(selSimula)){
				StringTokenizer st = new StringTokenizer(selSimula, "$$");
				while (st.hasMoreTokens()) {
					
					String codProducto = st.nextToken();
					bean = new Producto();
					
					bean.setCodProducto(codProducto);
					bean.setSimula("1");
					
					update("Operativizacion.updateCheckSimulaProduct", bean);
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			mapResult.put("msgError", "etiqueta.error.save");
		}
		
		return mapResult;
	}

	public Map<String, String> saveCheckProductoPlazos(String selPlazo,
			String codProductoPadre) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Map<String, String> mapParam = new HashMap<String, String>();
		ProductoPlazo bean = new ProductoPlazo();
		
		try{
		
			bean.setCodProducto(codProductoPadre);
			update("Operativizacion.updateInactiveAllCheckProductoPlazo", bean);
			
			if(StringUtils.isNotBlank(selPlazo)){
				StringTokenizer st = new StringTokenizer(selPlazo, "$$");
				while (st.hasMoreTokens()) {
					
					String codPlazo = st.nextToken();
					bean = new ProductoPlazo();
					
					bean.setCodPlazo(codPlazo);
					bean.setCodProducto(codProductoPadre);
					bean.setEstSeleccion("1");
					
					mapParam.put("codProducto", codProductoPadre);
					mapParam.put("codPlazo", codPlazo);
					
					List<ProductoPlazo> listSegmentoCP = queryForList("Operativizacion.getProductoPlazoByCode", mapParam);
					if(!listSegmentoCP.isEmpty()){
						update("Operativizacion.updateCheckProductoPlazo", bean);
					}else{
						insert("Operativizacion.insertProductoPlazo", bean);
					}					
				}
			}
			
		} catch (Exception e) {
			e.printStackTrace();
			mapResult.put("msgError", "etiqueta.error.save");
		}
		
		return mapResult;
	}

	public void saveAllCheckEmisoraSegmento(String allEmisoras,
		String allSegmentos, String codConfigProducto, String codProductoPadre) {

		if("S".equalsIgnoreCase(allEmisoras)){
			
			boolean isUpdate = false;
			Map<String, String> mapParam = new HashMap<String, String>();
			mapParam.put("codConfigProducto", codConfigProducto);
			mapParam.put("codProductoPadre", codProductoPadre);
			
			List<EmisoraConfigProd> listEmisoras = queryForList("Operativizacion.getAllEmisoras", mapParam);
			List<EmisoraConfigProd> listEmisorasCP = queryForList("Operativizacion.getAllEmisorasConfigProd", mapParam);
			
			for (int i = 0; i < listEmisoras.size(); i++) {
				
				isUpdate = false;
				EmisoraConfigProd bean = listEmisoras.get(i);
				String codEmisoraPadre = bean.getCodEmisora();
				bean.setSeleccionEmisora("1");
				
				for (int j = 0; j < listEmisorasCP.size(); j++) {
					String codEmisoraHijo = listEmisorasCP.get(j).getCodEmisora();
					if(codEmisoraPadre.equals(codEmisoraHijo)){
						isUpdate = true;
						break;
					}
				}
				
				if(isUpdate){
					update("Operativizacion.updateCheckEmisora", bean);					
				}else{
					insert("Operativizacion.insertEmisoraConfigProd", bean);
				}
			}
		}
		
		if("S".equalsIgnoreCase(allSegmentos)){
			
			boolean isUpdate = false;
			Map<String, String> mapParam = new HashMap<String, String>();
			mapParam.put("codConfigProducto", codConfigProducto);
			mapParam.put("codProductoPadre", codProductoPadre);
			
			List<SegmentoConfigProd> listSegmentos = queryForList("Operativizacion.getAllSegmentos", mapParam);
			List<SegmentoConfigProd> listSegmentosCP = queryForList("Operativizacion.getAllSegmentosConfigProd", mapParam);
			
			for (int i = 0; i < listSegmentos.size(); i++) {
				
				isUpdate = false;
				SegmentoConfigProd bean = listSegmentos.get(i);
				String codSegmentoPadre = bean.getCodSegmento();
				bean.setSeleccionSegmento("1");
				
				for (int j = 0; j < listSegmentosCP.size(); j++) {
					String codSegmentoHijo = listSegmentosCP.get(j).getCodSegmento();
					if(codSegmentoPadre.equals(codSegmentoHijo)){
						isUpdate = true;
						break;
					}
				}
				
				if(isUpdate){
					update("Operativizacion.updateCheckSegmento", bean);
				}else{
					insert("Operativizacion.insertSegmentoConfigProd", bean);
				}
			}
		}		
	}

	public List<Contrato> getProductExtraInfoByContrato(List<Contrato> list) {

		if(list != null && !list.isEmpty()){
			for (Contrato contrato : list) {
				
				String tipoProducto = contrato.getTipoProducto();
				Producto producto = (Producto)queryForObject("Operativizacion.getProductExtraInfoByContrato", tipoProducto);
				if(producto != null){
					contrato.setDesProducto(producto.getDesProducto());
					contrato.setFamiliaProducto(producto.getFamilia());
				}else{
					contrato.setDesProducto(tipoProducto);
				}
			}
		}
		
		return list;
	}

	public Map<String, String> getMapParametersByParameterType(String codTipoParametro) {

		Map<String, String> mapResult = new HashMap<String, String>();
		
		List<Parametro> listParametro = queryForList("Operativizacion.getParametersByParameterType", codTipoParametro);
		if(listParametro != null && !listParametro.isEmpty()){
			for (Parametro parametro : listParametro) {
				mapResult.put(parametro.getCodParametro(), parametro.getValParametro());
			}
		}
		
		return mapResult;
	}
	
	public List<Parametro> getParametersByParameterType(String codTipoParametro) {
		return queryForList("Operativizacion.getParametersByParameterType", codTipoParametro);
	}

	public List<Segmento> getAllSegmentosAdmin() {
		return queryForList("Operativizacion.getAllSegmentosAdmin");
	}

	public Map<String, String> saveSegmentoAdmin(String codSegmentoHdn,
		String codSegmento, String desSegmento, String seleccionSegmento) {

		Map<String, String> mapParam = new HashMap<String, String>();
		Map<String, String> mapResult = new HashMap<String, String>();
		Segmento bean = new Segmento();
		
		try {
			
			if("yes".equalsIgnoreCase(seleccionSegmento) || 
			   "on".equalsIgnoreCase(seleccionSegmento) || 
			   "1".equalsIgnoreCase(seleccionSegmento)){
				seleccionSegmento = "1";
			}else{
				seleccionSegmento = "0";
			}
			
			bean.setCodSegmentoHdn(codSegmentoHdn);
			bean.setSeleccionSegmento(seleccionSegmento);
			bean.setCodSegmento(codSegmento.toUpperCase().trim());
			bean.setDesSegmento(desSegmento.trim());
			
			mapParam.put("codSegmento", codSegmentoHdn);
			List<SegmentoConfigProd> listSegmento = queryForList("Operativizacion.getSegmentoByCode", mapParam);
			
			if(!listSegmento.isEmpty()){
				update("Operativizacion.updateSegmentoAdmin", bean);
				update("Operativizacion.updateSegmentoAdminConfigProd", bean);
			}else{
				insert("Operativizacion.insertSegmentoAdmin", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.segmento.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.segmento.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteSegmentosAdminByCode(String codes) throws Exception {
		
		if(!"".equals(codes)){
			
			Map<String, String> map = new HashMap<String, String>();
			map.put("codes", codes);
			
			boolean isDeletedDetail = true;
			SegmentoConfigProd bean;
			List<SegmentoConfigProd> listSegmentosCP = queryForList("Operativizacion.getSegmentosAllConfigProd", map);
			if(!listSegmentosCP.isEmpty()){
				for (int i = 0; i < listSegmentosCP.size(); i++) {
					
					bean = listSegmentosCP.get(i);
					if("1".equals(bean.getSeleccionSegmento())){
						isDeletedDetail = false;
						break;
					}				
				}
				
				if(isDeletedDetail){
					delete("Operativizacion.deleteSegmentoConfigProdByCodSegmento", map);
				}
			}
			
			//frk: si existen otras configuraciones relacionadas a 
			//los segmentos seleccionados no se deben de eliminar
			
			if(isDeletedDetail){
				delete("Operativizacion.deleteSegmentoByCode", map);
			}else{
				throw new Exception("ORA-02292");
			}
		}
	}

	public void saveAllCheckSegmentoAdmin() {
		update("Operativizacion.updateActiveAllCheckSegmentoAdmin");
	}

	public Map<String, String> saveCheckSegmentosAdmin(String selSegmentos) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Segmento bean = new Segmento();
		
		try{
		
			update("Operativizacion.updateInactiveAllCheckSegmentoAdmin");
			
			if(StringUtils.isNotBlank(selSegmentos)){
				StringTokenizer st = new StringTokenizer(selSegmentos, "$$");
				while (st.hasMoreTokens()) {
					
					String codSegmento = st.nextToken();
					bean = new Segmento();
					bean.setSeleccionSegmento("1");
					bean.setCodSegmento(codSegmento);				
					
					update("Operativizacion.updateCheckSegmentoAdmin", bean);
				}
			}
		
		} catch (Exception e) {
			e.printStackTrace();
			mapResult.put("msgError", "etiqueta.error.save");
		}
		
		return mapResult;
	}

	public String getValSegmentoByCode(String segmento) {

		if(StringUtils.isBlank(segmento)){
			return "0";
		}	
		
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("segmento", segmento);
		
		return (String)queryForObject("Operativizacion.getValSegmentoByCode", mapParam);
	}

	public BigDecimal getQuotaListIncomes(BigDecimal ingresoTotal) {

		Map<String, BigDecimal> mapParam = new HashMap<String, BigDecimal>();
		mapParam.put("ingresoTotal", ingresoTotal);
		
		String result = (String)queryForObject("Operativizacion.getQuotaListIncomes", mapParam);
		if(StringUtils.isBlank(result)){
			return BigDecimal.ZERO;
		}
		
		return new BigDecimal(result);
	}

	public List<Canal> getAllCanales() {
		return queryForList("Operativizacion.getAllCanales");
	}

	public Map<String, String> saveCanal(String codCanalHdn, String codCanal, String desCanal) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Canal bean = new Canal();
		
		try {
			
			if(StringUtils.isBlank(codCanalHdn)){
				codCanalHdn = "";
			}
			
			bean.setCodCanalHdn(codCanalHdn);
			bean.setCodCanal(codCanal.toUpperCase().trim());
			bean.setDesCanal(desCanal.trim());
			
			List<Canal> listCanal = queryForList("Operativizacion.getCanalByCode", bean.getCodCanalHdn());
			if(!listCanal.isEmpty()){
				update("Operativizacion.updateCanal", bean);				
				if(!bean.getCodCanalHdn().equals(bean.getCodCanal())){
					update("Operativizacion.updateCodCanalToSubCanal", bean);
				}
			}else{
				insert("Operativizacion.insertCanal", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.canal.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.canal.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteCanalesByCode(String codes) throws Exception {

		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", codes);
		
		delete("Operativizacion.deleteSubCanalesByCodCanal", map);	
		delete("Operativizacion.deleteCanalesByCode", map);
	}

	public List<SubCanal> getAllSubCanales(String codCanal) {
		return queryForList("Operativizacion.getAllSubCanales", codCanal);
	}

	public Map<String, String> saveSubCanal(String codSubCanalHdn,
		String codSubCanal, String desSubCanal, String codCanal) {

		Map<String, String> mapResult = new HashMap<String, String>();
		SubCanal bean = new SubCanal();
		
		try {
			
			if(StringUtils.isBlank(codSubCanalHdn)){
				codSubCanalHdn = "";
			}
			
			bean.setCodSubCanalHdn(codSubCanalHdn);
			bean.setCodSubCanal(codSubCanal.toUpperCase().trim());
			bean.setDesSubCanal(desSubCanal.trim());
			bean.setCodCanal(codCanal);
			
			List<SubCanal> listSubCanal = queryForList("Operativizacion.getSubCanalByCode", bean);
			if(!listSubCanal.isEmpty()){
				update("Operativizacion.updateSubCanal", bean);				
			}else{
				insert("Operativizacion.insertSubCanal", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.subcanal.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.subcanal.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteSubCanalesByCode(String codes, String codCanal) {

		Map<String, String> map = new HashMap<String, String>();
		map.put("codCanal", codCanal);
		map.put("codes", codes);
		
		delete("Operativizacion.deleteSubCanalesByCode", map);	
	}

	public Canal getCanalByCode(String codCanal) {
		return (Canal) queryForObject("Operativizacion.getCanalByCode", codCanal);
	}
	
	public SubCanal getSubCanalByCode(String codSubCanal, String codCanal) {
		SubCanal subCanal = new SubCanal();
		subCanal.setCodCanal(codCanal);
		subCanal.setCodSubCanal(codSubCanal);
		subCanal.setCodSubCanalHdn(codSubCanal);
		return (SubCanal) queryForObject("Operativizacion.getSubCanalByCode", subCanal);
	}

	public Parametro getParameterByCodes(String codParametro,
		String codTipoParametro) {

		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codTipoParametro", codTipoParametro);
		mapParam.put("codParametro", "'"+codParametro+"'");		
		
		List<Parametro> listParametro = queryForList("Operativizacion.getParameterByCodes", mapParam);
		if(listParametro != null && !listParametro.isEmpty()){
			return listParametro.get(0);
		}
		
		return new Parametro();
	}

	public List<TipoParametro> getAllTypeParameters() {
		return queryForList("Operativizacion.getAllTypeParameters");
	}

	public void deleteParametersByCode(String codes, String codTipoParametro) throws Exception{

		Map<String, String> map = new HashMap<String, String>();
		map.put("codTipoParametro", codTipoParametro);
		map.put("codes", codes);
		
		delete("Operativizacion.deleteParametersByCode", map);	
	}

	public boolean verifyParameterUniquePK(String codParametro,	String codTipoParametroPadre) {

		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codTipoParametro", codTipoParametroPadre);
		mapParam.put("codParametro", "'"+codParametro+"'");
		
		List<Parametro> listParametro = queryForList("Operativizacion.getParameterByCodes", mapParam);
		if(listParametro != null && !listParametro.isEmpty()){
			return true;
		}
		
		return false;
	}

	public void saveParameter(Parametro bean, boolean isNew) throws Exception {

		if(isNew){
			insert("Operativizacion.insertParameter", bean);		
		}else{
			update("Operativizacion.updateParameter", bean);
		}
	}

	/**********************************************
	 * @author frank.ayala
	 * FIN MANTENIMIENTOS
	 **********************************************/
	
	/**
	 * @author RDELOSREYES
	 */
	public Segmento getSegmentoByCode(String codSegmento) {
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codSegmento", codSegmento);
		Segmento segmento = (Segmento) queryForObject("Operativizacion.getSegmentoByCode", mapParam);
		return segmento;
	}
	
	//ini MCG20140716
	public List<Mensaje> getAllMensaje() {
		try {
			return queryForList("Operativizacion.getAllMensaje");
		} catch (Exception e) {
			// TODO: handle exception
			return null;
		}
		
		
	}

	public Map<String, String> saveMensaje(String codMensajeHdn, String codMensaje,
			String desMensaje,String activo) {

		Map<String, String> mapResult = new HashMap<String, String>();
		Mensaje bean = new Mensaje();
		
		try {
			
			if(StringUtils.isBlank(codMensajeHdn)){
				codMensajeHdn = "";
			}
			
			if("yes".equalsIgnoreCase(activo) || 
					   "on".equalsIgnoreCase(activo) || 
					   "1".equalsIgnoreCase(activo)){
						activo = "1";
			}else{
						activo = "0";
			}
			
			bean.setCodMensajeHdn(codMensajeHdn);
			bean.setCodMensaje(codMensaje.toUpperCase().trim());
			bean.setDesMensaje(desMensaje.trim());
			bean.setActivo(activo.toUpperCase());
			
			List<Plazo> listMensaje = queryForList("Operativizacion.getMensajeByCode", bean.getCodMensajeHdn());
			if(!listMensaje.isEmpty()){
				update("Operativizacion.updateMensaje", bean);			
			
			}else{
				insert("Operativizacion.insertMensaje", bean);
			}
			
		} catch (Exception e) {
			
			e.printStackTrace();
			
			try{
				if(e.getCause().getMessage().contains("ORA-00001")){
					mapResult.put("msgError", "etiqueta.error.adminform.mensaje.unique.constraint");
				}else if(e.getCause().getCause().getMessage().contains("ORA-02292")){
					mapResult.put("msgError", "etiqueta.error.adminform.mensaje.foreign.constraint");
				}else{
					mapResult.put("msgError", "etiqueta.error.save");
				}
			}catch(Exception excep){
				mapResult.put("msgError", "etiqueta.error.save");
			}
		}
		
		return mapResult;
	}

	public void deleteMensajeByCode(String codes) throws Exception{

		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", codes);
		
		delete("Operativizacion.deleteMensajeByCode", map);

	}
	
	public Mensaje getMensajeByCode(String codMensaje) throws Exception{
		Map<String, String> mapParam = new HashMap<String, String>();
		mapParam.put("codMensaje", codMensaje);
		Mensaje mensaje = (Mensaje) queryForObject("Operativizacion.getMensajeByCodeMsn", mapParam);
		return mensaje;
	}

	
	public List<Tabla> getListRoles() {
		return queryForList("SegUsuario.getListRoles");
	}
	
	public List<Tabla> getListPerfilRoles(String id) {
		
		Map<String, String> map = new HashMap<String, String>();
		map.put("codPerfil", id);
		return queryForList("SegUsuario.getListPerfilRoles", map);
	}
	
	
	public List<Tabla> getListPerilesLocal() {
		return queryForList("SegUsuario.getListPerilesLocal");
	}
	
	public void savePerfilRol(PerfilRol bean) throws Exception {
		
		String codigo = String.valueOf(bean.getIdPerfil());

		
		if(StringUtils.isNotBlank(codigo)){
			codigo = codigo.trim();
		}

		
		PerfilRol param = new PerfilRol();
		String[] arrayRol = bean.getCmbReasonDestinationp();
		

			Map<String, String> map = new HashMap<String, String>();
			map.put("codes", "'"+bean.getIdPerfil()+"'");
			delete("SegUsuario.deletePerfilRolByCode", map);
			
			
			for (int i = 0; i < arrayRol.length; i++) {	
				
				param.setIdRol(arrayRol[i]);
				param.setIdPerfil(codigo);
				insert("SegUsuario.insertPerfilRol", param);
			}
		
	}

	
	public List<LogDataLoad> getAllLogDataLoad() {
		return queryForList("SegUsuario.getAllLogDataLoad");
	}
	public void deleteLogDataLoadByCode(String concatIds) throws Exception {
		Map<String, String> map = new HashMap<String, String>();
		map.put("codes", concatIds);		
		delete("SegUsuario.deleteLogDataLoadByCode", map);
	}
	


	//fin MCG20140716
	
}
